home *** CD-ROM | disk | FTP | other *** search
/ Atari Mega Archive 1 / Atari Mega Archive - Volume 1.iso / lists / mint / l_1199 / 1616 < prev    next >
Encoding:
Internet Message Format  |  1994-08-27  |  6.7 KB
  1. From: Kay Roemer <roemer@informatik.uni-frankfurt.de>
  2. Posted-Date: Tue, 21 Jun 94 15:52:04 MESZ
  3. Received-Date: Tue, 21 Jun 94 15:52:04 +0200
  4. Message-Id: <9406211352.AA10584@hera.rbi.informatik.uni-frankfurt.de>
  5. Subject: ser. overrun/daedlock fix
  6. To: mint@atari.archive.umich.edu
  7. Date: Tue, 21 Jun 94 15:52:04 MESZ
  8. Mailer: Elm [revision: 70.85]
  9.  
  10. The following set of patches rel to h1 Megapatch (sorry, hadn't yet
  11. the time to get h2 or h3) is a better solution (at least I think) to
  12. the 'endless serial overrun' story, because it avoids the spl7()
  13. in Fselect() completely plus deadlock fix.
  14.  
  15. The solution is as follows:
  16.  
  17. curproc->wait_cond = condition;
  18. while (curproc->wait_cond == condition) {
  19.     sleep (SELECT_Q | 0x100, condition);
  20. }
  21.  
  22. works the same as
  23.  
  24. curproc->wait_cond = condition;
  25. sr = spl7();
  26. while (curproc->wait_cond == condition) {
  27.     sleep (SELECT_Q, condition);
  28. }
  29. spl(sr);
  30.  
  31. The 0x100 tells sleep() to return without sleeping when curproc->wait_cond
  32. changes. This way we don't need spl7 (avoiding endless serial overruns).
  33. Also fixes a deadlock with checkkeys/checkbttys. They are called from
  34. sleep and may wakeselect() curproc. But sleep used to reset curproc->wait_cond
  35. to (long)wakeselect causing curproc to sleep forever.
  36.  
  37. Kay.
  38.  
  39. *** ../mint-110h1.orig/proc.c    Mon Jun 20 23:20:20 1994
  40. --- proc.c    Mon Jun 20 23:24:10 1994
  41. ***************
  42. *** 9,15 ****
  43.   #include "mint.h"
  44.   #include "xbra.h"
  45.   
  46. ! static void do_wakeup_things P_((short sr));
  47.   
  48.   extern short proc_clock;
  49.   
  50. --- 9,15 ----
  51.   #include "mint.h"
  52.   #include "xbra.h"
  53.   
  54. ! static void do_wakeup_things P_((void));
  55.   
  56.   extern short proc_clock;
  57.   
  58. ***************
  59. *** 419,426 ****
  60.    */
  61.   
  62.   static void
  63. ! do_wakeup_things(sr)
  64. ! short sr;
  65.   {
  66.   /*
  67.    * check for stack underflow, just in case
  68. --- 419,425 ----
  69.    */
  70.   
  71.   static void
  72. ! do_wakeup_things()
  73.   {
  74.   /*
  75.    * check for stack underflow, just in case
  76. ***************
  77. *** 430,438 ****
  78.   
  79.       p = curproc;
  80.   
  81. -     if ((sr & 0x700) < 0x500) {
  82. - /* skip all this if int level is too high */
  83. - 
  84.       if ( p->pid != 0 &&
  85.            ((long)&foo) < (long)p->stack + ISTKSIZE + 512 ) {
  86.           ALERT("stack underflow");
  87. --- 429,434 ----
  88. ***************
  89. *** 455,461 ****
  90.       checkalarms();
  91.       if (p->sigpending)
  92.           check_sigs();        /* check for signals */
  93. -     }
  94.   
  95.       if (p->slices >= 0) {
  96.       proc_clock = TIME_SLICE;    /* get a fresh time slice */
  97. --- 451,456 ----
  98. ***************
  99. *** 472,483 ****
  100.    */
  101.   
  102.   int ARGS_ON_STACK 
  103. ! sleep(que, cond)
  104. !     int que;
  105.       long cond;
  106.   {
  107.       PROC *p;
  108. !     short sr;
  109.       ulong onsigs = curproc->nsigs;
  110.       extern short kintr;    /* in bios.c */
  111.   #ifndef MULTITOS
  112. --- 467,478 ----
  113.    */
  114.   
  115.   int ARGS_ON_STACK 
  116. ! sleep(_que, cond)
  117. !     int _que;
  118.       long cond;
  119.   {
  120.       PROC *p;
  121. !     short sr, que = _que & 0xff;
  122.       ulong onsigs = curproc->nsigs;
  123.       extern short kintr;    /* in bios.c */
  124.   #ifndef MULTITOS
  125. ***************
  126. *** 490,509 ****
  127.    * if there have been keyboard interrupts since our last sleep, check for
  128.    * special keys like CTRL-ALT-Fx
  129.    */
  130. ! 
  131. !     sr = spl7();
  132. !     if (kintr && (sr & 0x700) < 0x500) {
  133. ! /* can't call checkkeys if sleep was called with interrupts off  -nox */
  134. !         spl(sr);
  135.           (void)checkkeys();
  136. -         sr = spl7();
  137.           kintr = 0;
  138.       }
  139.   
  140. !     if (que == READY_Q && !sys_q[READY_Q]) {
  141.   /* we're just going to wake up again right away! */
  142.           spl(sr);
  143. !         do_wakeup_things(sr);
  144.           return (onsigs != curproc->nsigs);
  145.       }
  146.   
  147. --- 485,507 ----
  148.    * if there have been keyboard interrupts since our last sleep, check for
  149.    * special keys like CTRL-ALT-Fx
  150.    */
  151. !     checkbttys();
  152. !     if (kintr) {
  153.           (void)checkkeys();
  154.           kintr = 0;
  155.       }
  156.   
  157. !     sr = spl7();
  158. ! /*
  159. !  * kay: If _que & 0x100 != 0 then take curproc->wait_cond != cond as an
  160. !  * indicatation that the wakeup has already happend before we actually
  161. !  * go to sleep and return immediatly.
  162. !  */
  163. !     if ((_que & 0x100 && curproc->wait_cond != cond) ||
  164. !         (que == READY_Q && !sys_q[READY_Q])) {
  165.   /* we're just going to wake up again right away! */
  166.           spl(sr);
  167. !         do_wakeup_things();
  168.           return (onsigs != curproc->nsigs);
  169.       }
  170.   
  171. ***************
  172. *** 559,566 ****
  173.   
  174.       rm_q(READY_Q, p);
  175.   
  176. -     spl(sr);
  177. - 
  178.       if (save_context(&(curproc->ctxt[CURRENT]))) {
  179.   /*
  180.    * restore per-process variables here
  181. --- 557,562 ----
  182. ***************
  183. *** 571,577 ****
  184.   #endif
  185.               *((void **)0x44eL) = curproc->logbase;
  186.   #endif
  187. !         do_wakeup_things(sr);
  188.           return (onsigs != curproc->nsigs);
  189.       }
  190.   /*
  191. --- 567,573 ----
  192.   #endif
  193.               *((void **)0x44eL) = curproc->logbase;
  194.   #endif
  195. !         do_wakeup_things();
  196.           return (onsigs != curproc->nsigs);
  197.       }
  198.   /*
  199. ***************
  200. *** 583,588 ****
  201. --- 579,590 ----
  202.   #endif
  203.           curproc->logbase = *((void **)0x44eL);
  204.   #endif
  205. + 
  206. + /*
  207. +  * kay: We were at spl7 when doing the save_context(). Correct this.
  208. +  */
  209. +     curproc->ctxt[CURRENT].sr &= ~0x0700;
  210. +     curproc->ctxt[CURRENT].sr |= sr & 0x0700;
  211.       curproc->ctxt[CURRENT].regs[0] = 1;
  212.       curproc = p;
  213.       proc_clock = TIME_SLICE;    /* fresh time */
  214. *** ../mint-110h1.orig/dosfile.c    Mon Jun 20 23:19:54 1994
  215. --- dosfile.c    Mon Jun 20 11:54:44 1994
  216. ***************
  217. *** 977,983 ****
  218.       FILEPTR *f;
  219.       PROC *p;
  220.       TIMEOUT *t;
  221. -     short sr;
  222.   
  223.       if (xfdp)
  224.           *xfdp = 0;
  225. --- 977,982 ----
  226. ***************
  227. *** 1045,1051 ****
  228.       }
  229.   
  230.       if (count == 0) {
  231. -         ulong onsigs;
  232.           /* OK, now let's set a timeout */
  233.   
  234.           if (timeout) {
  235. --- 1044,1049 ----
  236. ***************
  237. *** 1054,1079 ****
  238.               t = 0;
  239.           }
  240.   
  241. -         TRACE(("sleeping in Fselect"));
  242. -         sr = spl7();
  243. - 
  244.       /* curproc->wait_cond changes when data arrives or the timeout happens */
  245. -         onsigs = curproc->nsigs;
  246.           while (curproc->wait_cond == (long)wakeselect) {
  247. - #if 0
  248. - /* better not call BIOS with interrupts off, especially not Bconin... :) */
  249.               TRACE(("sleeping in Fselect"));
  250. ! #endif
  251. !             sleep(SELECT_Q, (long)wakeselect);
  252. !             if (curproc->sigpending) {
  253. !                 spl(sr);    /* check for signals */
  254. !                 check_sigs();
  255. !                 sr = spl7();
  256. !             }
  257. !             if (onsigs != curproc->nsigs)
  258.                   break;
  259.           }
  260. -         spl(sr);
  261.   
  262.       /* we can cancel the time out now (if it hasn't already happened) */
  263.           if (t) canceltimeout(t);
  264. --- 1052,1072 ----
  265.               t = 0;
  266.           }
  267.   
  268.       /* curproc->wait_cond changes when data arrives or the timeout happens */
  269.           while (curproc->wait_cond == (long)wakeselect) {
  270.               TRACE(("sleeping in Fselect"));
  271. !             /*
  272. !              * The 0x100 tells sleep() to return without sleeping
  273. !              * when curproc->wait_cond changes. This way we don't
  274. !              * need spl7 (avoiding endless serial overruns).
  275. !              * Also fixes a deadlock with checkkeys/checkbttys.
  276. !              * They are called from sleep and may wakeselect()
  277. !              * curproc. But sleep used to reset curproc->wait_cond
  278. !              * to wakeselect causing curproc to sleep forever.
  279. !              */
  280. !             if (sleep(SELECT_Q|0x100, (long)wakeselect))
  281.                   break;
  282.           }
  283.   
  284.       /* we can cancel the time out now (if it hasn't already happened) */
  285.           if (t) canceltimeout(t);
  286.